PC World Komputer 2010 April/PCWorld0410.iso/hity wydania/Ubuntu 9.10 PL/karmelkowy-koliberek-9.10-netbook-remix-PL.iso/casper/filesystem.squashfs/usr/share/pyshared/nevow/livepage.pyc

Python Compiled Bytecode | 2009-03-23 | 41KB | 931 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

'''Provides a bidirectional channel for sending out-of-band
events between client and server without refreshing the whole
page.
'''
import itertools
import types
import warnings
from zope.interface import implements, Interface
from twisted.internet import defer, error
from twisted.internet.task import LoopingCall
from twisted.python import log
from nevow import tags, inevow, context, static, flat, rend, url, util, stan
DEBUG = False
_jslog = None

def _openjslog():
    global _jslog
    if _jslog is None:
        _jslog = file('js.log', 'w')
        _jslog.write('**********\n')
        _jslog.flush()

    return _jslog


def jslog(*x):
    if DEBUG:
        mylog = _openjslog()
        for y in x:
            mylog.write(str(y))

        mylog.flush()



class JavascriptContext(context.WovenContext):

    def __init__(self, parent = None, tag = None, isAttrib = None, inJSSingleQuoteString = None, remembrances = None):
        super(JavascriptContext, self).__init__(parent, tag, inJS = True, isAttrib = isAttrib, inJSSingleQuoteString = inJSSingleQuoteString, remembrances = None)



class TimeoutException(Exception):
    pass


class ClientSideException(Exception):
    pass


class SingleQuote(object):

    def __init__(self, children):
        self.children = children


    def __repr__(self):
        return '%s(%s)' % (type(self).__name__, self.children)



def flattenSingleQuote(singleQuote, ctx):
    new = JavascriptContext(ctx, tags.invisible[singleQuote], inJSSingleQuoteString = True)
    return flat.serialize(singleQuote.children, new)

flat.registerFlattener(flattenSingleQuote, SingleQuote)

class _js(object):
    '''Stan for Javascript. There is a convenience instance of this
    class named "js" in the livepage module which you should use
    instead of the _js class directly.

    Marker indicating literal Javascript should be rendered.
    No escaping will be performed.

    When inside a JavascriptContext, Nevow will automatically put
    apostrophe quote marks around any Python strings it renders.
    This makes turning a Python string into a JavaScript string very
    easy. However, there are often situations where you wish to
    generate some literal Javascript code and do not wish quote
    marks to be placed around it. In this situation, the js object
    should be used.

    The simplest usage is to simply pass a python string to js.
    When the js object is rendered, the python string will be
    rendered as if it were literal javascript. For example:

        client.send(js("alert(\'hello\')"))

    However, to make the generation of Javascript more
    convenient, the js object also provides safe implementations
    of __getattr__, __call__, and __getitem__. See the following
    examples to get an idea of how to use it. The Python code
    is to the left of the -> and the Javascript which results is
    to the right.

        js("alert(\'any javascript you like\')") -> alert(\'any javascript you like\')

        js.window.title -> window.title

        js.document.getElementById(\'foo\') -> document.getElementById(\'foo\')

        js.myFunction(\'my argument\') -> myFunction(\'my argument\')

        js.myFunction(True, 5, "it\'s a beautiful day") -> myFunction(true, 5, \'it\\\'s a beautiful day\')

        js.document.all["something"] -> document.all[\'something\']

        js[1, 2] -> [1, 2]

    XXX TODO support javascript object literals somehow? (They look like dicts)
    perhaps like this:

        js["one": 1, "two": 2] -> {"one": 1, "two": 2}

    The livepage module includes many convenient instances of the js object.
    It includes the literals:

        document
        window
        this
        self

    It includes shorthand for commonly called javascript functions:

        alert -> alert
        get -> document.getElementById
        set -> nevow_setNode
        append -> nevow_appendNode
        prepend -> nevow.prependNode
        insert -> nevow.insertNode

    It includes convenience calls against the client-side server object:

        server.handle(\'callMe\') -> server.handle(\'callMe\')

    It includes commonly-used fragments of javascript:

        stop -> ; return false;
        eol -> \\n

    Stop is used to prevent the browser from executing it\'s default
    event handler. For example:

        button(onclick=[server.handle(\'click\'), stop]) -> <button onclick="server.handle(\'click\'); return false;" />

    EOL is currently required to separate statements (this requirement
    may go away in the future). For example:

        client.send([
            alert(\'hello\'), eol,
            alert(\'goodbye\')])

    XXX TODO: investigate whether rendering a
 between list elements
    in a JavascriptContext has any ill effects.
    '''

    def __init__(self, name = None):
        if name is None:
            name = []

        if isinstance(name, str):
            name = [
                stan.raw(name)]

        self._children = name


    def __getattr__(self, name):
        if name == 'clone':
            raise RuntimeError("Can't clone")
        name == 'clone'
        if self._children:
            newchildren = self._children[:]
            newchildren.append(stan.raw('.' + name))
            return self.__class__(newchildren)
        return self.__class__(name)


    def __call__(self, *args):
        if not self._children:
            return self.__class__(args[0])
        newchildren = self._children[:]
        stuff = []
        for x in args:
            if isinstance(x, (basestring, stan.Tag, types.FunctionType, types.MethodType, types.UnboundMethodType)):
                x = (stan.raw("'"), SingleQuote(x), stan.raw("'"))

            stuff.append((x, stan.raw(',')))

        if stuff:
            stuff[-1] = stuff[-1][0]

        newchildren.extend([
            stan.raw('('),
            stuff,
            stan.raw(')')])
        return self.__class__(newchildren)


    def __getitem__(self, args):
        if not isinstance(args, (tuple, list)):
            args = (args,)

        newchildren = self._children[:]
        stuff = [ (x, stan.raw(',')) for x in args ]
        newchildren.extend([
            stan.raw('['),
            stuff,
            stan.raw(']')])
        return self.__class__(newchildren)


    def __iter__(self):
        '''Prevent an infinite loop if someone tries to do
        for x in jsinstance:
        '''
        raise NotImplementedError, 'js instances are not iterable. (%r)' % (self,)


    def __repr__(self):
        return '%s(%r)' % (type(self).__name__, self._children)



def flattenJS(theJS, ctx):
    new = JavascriptContext(ctx, tags.invisible[theJS])
    return flat.serialize(theJS._children, new)

flat.registerFlattener(flattenJS, _js)
js = _js()
document = _js('document')
get = document.getElementById
window = _js('window')
this = _js('this')
self = _js('self')
server = _js('server')
alert = _js('alert')
stop = _js('; return false;')
eol = tags.raw('\n')
set = js.nevow_setNode
append = js.nevow_appendNode
prepend = js.nevow_prependNode
insert = js.nevow_insertNode

def assign(where, what):
    '''Assign what to where. Equivalent to
    where = what;
    '''
    return _js([
        where,
        stan.raw(' = '),
        what])

setq = assign

def var(where, what):
    """Define local variable 'where' and assign 'what' to it.
    Equivalent to var where = what;
    """
    return _js([
        stan.raw('var '),
        where,
        stan.raw(' = '),
        what,
        stan.raw(';')])


def anonymous(block):
    '''Turn block (any stan) into an anonymous JavaScript function
    which takes no arguments. Equivalent to

    function () {
        block
    }
    '''
    return _js([
        stan.raw('function() {\n'),
        block,
        stan.raw('\n}')])


class IClientHandle(Interface):

    def hookupOutput(output, finisher = None):
        '''hook up an output conduit to this live evil instance.
        '''
        pass


    def send(script):
        '''send a script through the output conduit to the browser.
        If no output conduit is yet hooked up, buffer the script
        until one is.
        '''
        pass


    def handleInput(identifier, *args):
        '''route some input from the browser to the appropriate
        destination.
        '''
        pass



class IHandlerFactory(Interface):

    def locateHandler(ctx, name):
        '''Locate a handler callable with the given name.
        '''
        pass



class _transient(object):

    def __init__(self, transientId, arguments = None):
        self.transientId = transientId
        if arguments is None:
            arguments = []
        elif isinstance(arguments, tuple):
            arguments = list(arguments)
        else:
            raise TypeError, 'Arguments must be None or tuple'
        self.arguments = arguments is None


    def __call__(self, *arguments):
        return type(self)(self.transientId, arguments)



def flattenTransient(transient, ctx):
    thing = js.server.handle('--transient.%s' % (transient.transientId,), *transient.arguments)
    return flat.serialize(thing, ctx)

flat.registerFlattener(flattenTransient, _transient)

class ClientHandle(object):
    '''An object which represents the client-side webbrowser.
    '''
    implements(IClientHandle)
    outputConduit = None

    def __init__(self, livePage, handleId, refreshInterval, targetTimeoutCount):
        self.refreshInterval = refreshInterval
        self.targetTimeoutCount = targetTimeoutCount
        self.timeoutCount = 0
        self.livePage = livePage
        self.handleId = handleId
        self.outputBuffer = []
        self.bufferDeferreds = []
        self.closed = False
        self.closeNotifications = []
        self.firstTime = True
        self.timeoutLoop = LoopingCall(self.checkTimeout)
        if refreshInterval:
            self.timeoutLoop.start(self.refreshInterval)

        self._transients = { }
        self.transientCounter = itertools.count().next
        self.nextId = itertools.count().next


    def transient(self, what, *args):
        """Register a transient event handler, 'what'.
        The callable 'what' can only be invoked by the
        client once before being garbage collected.
        Additional attempts to invoke the handler
        will fail.
        """
        transientId = str(self.transientCounter())
        self._transients[transientId] = what
        return _transient(transientId, args)


    def popTransient(self, transientId):
        """Remove a transient previously registered
        by a call to transient. Normally, this will be done
        automatically when the transient is invoked.
        However, you can invoke it yourself if you wish
        to revoke the client's capability to call the
        transient handler.
        """
        if DEBUG:
            print 'TRANSIENTS', self._transients

        return self._transients.pop(transientId)


    def _actuallySend(self, scripts):
        output = self.outputConduit
        written = []

        def writer(write):
            written.append(write)


        def finisher(finish):
            towrite = '\n'.join(written)
            jslog('<<<<<<\n%s\n' % towrite)
            output.callback(towrite)

        flat.flattenFactory(scripts, self.outputContext, writer, finisher)
        self.outputConduit = None
        self.outputContext = None


    def send(self, *script):
        '''Send the stan "script", which can be flattened to javascript,
        to the browser which is connected to this handle, and evaluate
        it in the context of the browser window.
        '''
        if self.outputConduit:
            self._actuallySend(script)
        else:
            self.outputBuffer.append(script)
            self.outputBuffer.append(eol)


    def setOutput(self, ctx, output):
        self.timeoutCount = 0
        self.outputContext = ctx
        self.outputConduit = output
        if self.outputBuffer:
            if DEBUG:
                print 'SENDING BUFFERED', self.outputBuffer

            self._actuallySend(self.outputBuffer)
            self.outputBuffer = []



    def _actuallyPassed(self, result, deferreds):
        for d in deferreds:
            d.callback(result)



    def _actuallyFailed(self, failure, deferreds):
        for d in deferreds:
            d.errback(failure)



    def checkTimeout(self):
        if self.outputConduit is not None:
            self.send(_js('null;'))
            return None
        self.timeoutCount += 1


    def outputGone(self, failure, output):
        self.outputConduit = None
        if failure.check(error.ConnectionDone):
            self._closeComplete()
        else:
            self._closeComplete(failure)


    def _closeComplete(self, failure = None):
        if self.closed:
            return None
        self.closed = True
        self.timeoutLoop.stop()
        self.timeoutLoop = None
        for notify in self.closeNotifications[:]:
            if failure is not None:
                notify.errback(failure)
                continue
            self.closed
            notify.callback(None)

        self.closeNotifications = []


    def notifyOnClose(self):
        """This will return a Deferred that will be fired when the
        connection is closed 'normally', i.e. in response to handle.close()
        . If the connection is lost in any other way (because the browser
        navigated to another page, the browser was shut down, the network
        connection was lost, or the timeout was reached), this will errback
        instead."""
        d = defer.Deferred()
        self.closeNotifications.append(d)
        return d


    def close(self, executeScriptBeforeClose = ''):
        if DEBUG:
            print 'CLOSE WAS CALLED'

        d = self.notifyOnClose()
        self.send(js.nevow_closeLive(executeScriptBeforeClose))
        return d


    def set(self, where, what):
        self.send(js.nevow_setNode(where, what))


    def prepend(self, where, what):
        self.send(js.nevow_prependNode(where, what))


    def append(self, where, what):
        self.send(js.nevow_appendNode(where, what))


    def alert(self, what):
        self.send(js.alert(what))


    def call(self, what, *args):
        self.send(js(what)(*args))


    def sendScript(self, string):
        warnings.warn('[0.5] nevow.livepage.ClientHandle.sendScript is deprecated, use send instead.', DeprecationWarning, 2)
        self.send(string)



class DefaultClientHandleFactory(object):
    clientHandleClass = ClientHandle

    def __init__(self):
        self.clientHandles = { }
        self.handleCounter = itertools.count().next


    def newClientHandle(self, livePage, refreshInterval, targetTimeoutCount):
        handleid = str(self.handleCounter())
        handle = self.clientHandleClass(livePage, handleid, refreshInterval, targetTimeoutCount)
        self.clientHandles[handleid] = handle
        (None, handle.notifyOnClose().addBoth)((lambda ign: self.deleteHandle(handleid)))
        return handle


    def deleteHandle(self, handleid):
        del self.clientHandles[handleid]


    def getHandleForId(self, handleId):
        '''Override this to restore old handles on demand.
        '''
        return self.clientHandles[handleId]


theDefaultClientHandleFactory = DefaultClientHandleFactory()

class OutputHandlerResource:
    implements(inevow.IResource)

    def __init__(self, clientHandle):
        self.clientHandle = clientHandle


    def locateChild(self, ctx, segments):
        raise NotImplementedError()


    def renderHTTP(self, ctx):
        request = inevow.IRequest(ctx)
        neverEverCache(request)
        activeChannel(request)
        ctx.remember(jsExceptionHandler, inevow.ICanHandleException)
        request.channel._savedTimeOut = None
        d = defer.Deferred()
        request.notifyFinish().addErrback(self.clientHandle.outputGone, d)
        jsContext = JavascriptContext(ctx, tags.invisible())
        self.clientHandle.livePage.rememberStuff(jsContext)
        jsContext.remember(self.clientHandle, IClientHandle)
        if self.clientHandle.firstTime:
            self.clientHandle.livePage.goingLive(jsContext, self.clientHandle)
            self.clientHandle.firstTime = False

        self.clientHandle.setOutput(jsContext, d)
        return d



class InputHandlerResource:
    implements(inevow.IResource)

    def __init__(self, clientHandle):
        self.clientHandle = clientHandle


    def locateChild(self, ctx, segments):
        raise NotImplementedError()


    def renderHTTP(self, ctx):
        self.clientHandle.timeoutCount = 0
        request = inevow.IRequest(ctx)
        neverEverCache(request)
        activeChannel(request)
        ctx.remember(self.clientHandle, IClientHandle)
        ctx.remember(jsExceptionHandler, inevow.ICanHandleException)
        self.clientHandle.livePage.rememberStuff(ctx)
        handlerName = request.args['handler-name'][0]
        arguments = request.args.get('arguments', ())
        jslog('>>>>>>\n%s %s\n' % (handlerName, arguments))
        if handlerName.startswith('--transient.'):
            handler = self.clientHandle.popTransient(handlerName.split('.')[-1])
        else:
            handler = self.clientHandle.livePage.locateHandler(ctx, request.args['handler-path'], handlerName)
        jsContext = JavascriptContext(ctx, tags.invisible[handler])
        towrite = []

        def writer(r):
            jslog('WRITE ', r)
            towrite.append(r)


        def finisher(r):
            jslog('FINISHED', r)
            writestr = ''.join(towrite)
            jslog('<><><>\n%s\n' % (writestr,))
            request.write(writestr)
            request.finish()
            return r

        result = handler(jsContext, *arguments)
        jslog('RESULT ', result)
        if result is None:
            return defer.succeed('')
        return self.clientHandle.livePage.flattenFactory(result, jsContext, writer, finisher)



class DefaultClientHandlesResource(object):
    implements(inevow.IResource)
    clientResources = {
        'input': InputHandlerResource,
        'output': OutputHandlerResource }
    clientFactory = theDefaultClientHandleFactory

    def locateChild(self, ctx, segments):
        handleId = segments[0]
        handlerType = segments[1]
        client = self.clientFactory.clientHandles[handleId]
        return (self.clientResources[handlerType](client), segments[2:])


theDefaultClientHandlesResource = DefaultClientHandlesResource()

class attempt(defer.Deferred):
    '''Attempt to do \'stuff\' in the browser. callback on the server
    if \'stuff\' executes without raising an exception. errback on the
    server if \'stuff\' raises a JavaScript exception in the client.

    Used like this:

    def printIt(what):
        print "Woo!", what

    C = IClientHandle(ctx)
    C.send(
        attempt(js("1+1")).addCallback(printIt))

    C.send(
        attempt(js("thisWillFail")).addErrback(printIt))
    '''

    def __init__(self, stuff):
        self.stuff = stuff
        defer.Deferred.__init__(self)



def flattenAttemptDeferred(d, ctx):

    def attemptComplete(ctx, result, reason = (None,)):
        if result == 'success':
            d.callback(None)
        else:
            d.errback(ClientSideException(reason))

    transient = IClientHandle(ctx).transient(attemptComplete)
    return flat.serialize([
        _js('try {\n    '),
        d.stuff,
        _js('\n    '),
        transient('success'),
        _js('\n} catch (e) {\n    '),
        transient('failure', js.e),
        _js('}')], ctx)

flat.registerFlattener(flattenAttemptDeferred, attempt)

class IOutputEvent(Interface):
    pass


class IInputEvent(Interface):
    pass


class ExceptionHandler(object):

    def renderHTTP_exception(self, ctx, failure):
        log.msg('Exception during input event:')
        log.err(failure)
        request = inevow.IRequest(ctx)
        request.write("throw new Error('Server side error: %s')" % (failure.getErrorMessage().replace("'", "\\'").replace('\n', '\\\n'),))
        request.finish()


    def renderInlineException(self, ctx, reason):
        """TODO: I don't even think renderInlineException is ever called by anybody
        """
        pass


jsExceptionHandler = ExceptionHandler()

def neverEverCache(request):
    ''' Set headers to indicate that the response to this request should never,
    ever be cached.
    '''
    request.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate')
    request.setHeader('Pragma', 'no-cache')


def activeChannel(request):
    """Mark this connection as a 'live' channel by setting the Connection: close
    header and flushing all headers immediately.
    """
    request.setHeader('Connection', 'close')
    request.write('')


class LivePage(rend.Page):
    '''A Page which is Live provides asynchronous, bidirectional RPC between
    Python on the server and JavaScript in the client browser. A LivePage must
    include the "liveglue" JavaScript which includes a unique identifier which
    is assigned to every page render of a LivePage and the JavaScript required
    for the client to communicate asynchronously with the server.

    A LivePage grants the client browser the capability of calling server-side
    Python methods using a small amount of JavaScript code. There are two
    types of Python handler methods, persistent handlers and transient handlers.

    1) To grant the client the capability to call a persistent handler over and over
        as many times as it wishes, subclass LivePage and provide handle_foo
        methods. The client can then call handle_foo by executing the following
        JavaScript:

          server.handle(\'foo\')

        handle_foo will be invoked because the default implementation of
        locateHandler looks for a method prefixed handle_*. To change this,
        override locateHandler to do what you wish.

    2) To grant the client the capability of calling a handler once and
        exactly once, use ClientHandle.transient to register a callable and
        embed the return result in a page to render JavaScript which will
        invoke the transient handler when executed. For example:

        def render_clickable(self, ctx, data):
            def hello(ctx):
                return livepage.alert("Hello, world. You can only click me once.")

            return ctx.tag(onclick=IClientHandle(ctx).transient(hello))

        The return result of transient can also be called to pass additional
        arguments to the transient handler. For example:

        def render_choice(self, ctx, data):
            def chosen(ctx, choseWhat):
                return livepage.set(
                    "choosable",
                    ["Thanks for choosing ", choseWhat])

            chooser = IClientHandle(ctx).transient(chosen)

            return span(id="choosable")[
                "Choose one:",
                p(onclick=chooser("one"))["One"],
                p(onclick=chooser("two"))["Two"]]

        Note that the above situation displays temporary UI to the
        user. When the user invokes the chosen handler, the UI which
        allowed the user to invoke the chosen handler is removed from
        the client. Thus, it is important that the transient registration
        is deleted once it is invoked, otherwise uncollectable garbage
        would accumulate in the handler dictionary. It is also important
        that either the one or the two button consume the same handler,
        since it is an either/or choice. If two handlers were registered,
        the untaken choice would be uncollectable garbage.
    '''
    refreshInterval = 30
    targetTimeoutCount = 3
    clientFactory = theDefaultClientHandleFactory

    def renderHTTP(self, ctx):
        if not self.cacheable:
            neverEverCache(inevow.IRequest(ctx))

        return rend.Page.renderHTTP(self, ctx)


    def locateHandler(self, ctx, path, name):
        return getattr(self, 'handle_%s' % (name,))


    def goingLive(self, ctx, handle):
        """This particular LivePage instance is 'going live' from the
        perspective of the ClientHandle 'handle'. Override this to
        get notified when a new browser window observes this page.

        This means that a new user is now looking at the page, an old
        user has refreshed the page, or an old user has opened a new
        window or tab onto the page.

        This is the first time the ClientHandle instance is available
        for general use by the server. This Page may wish to keep
        track of the ClientHandle instances depending on how your
        application is set up.
        """
        pass


    def child_livepage_client(self, ctx):
        return theDefaultClientHandlesResource


    def render_liveid(self, ctx, data):
        warnings.warn("You don't need a liveid renderer any more; just liveglue is fine.", DeprecationWarning)
        return ''

    cacheable = False

    def render_liveglue(self, ctx, data):
        if not self.cacheable:
            handleId = ("'", self.clientFactory.newClientHandle(self, self.refreshInterval, self.targetTimeoutCount).handleId, "'")
        else:
            handleId = 'null'
        return [
            tags.script(type = 'text/javascript')[('var nevow_clientHandleId = ', handleId, ';')],
            tags.script(type = 'text/javascript', src = url.here.child('nevow_glue.js'))]


setattr(LivePage, 'child_nevow_glue.js', static.File(util.resource_filename('nevow', 'liveglue.js'), 'text/javascript'))
glue = tags.directive('liveglue')
ctsTemplate = "nevow_clientToServerEvent('%s',this,''%s)%s"
handledEventPostlude = '; return false;'

class handler(object):
    callme = None
    args = ()
    identifier = None

    def __init__(self, *args, **kw):
        '''**DEPRECATED** [0.5]

        Handler is now deprecated. To expose server-side code to the client
        to be called by JavaScript, read the LivePage docstring.
        '''
        warnings.warn("[0.5] livepage.handler is deprecated; Provide handle_foo methods (or override locateHandler) on your LivePage and use (in javascript) server.handle('foo'), or use ClientHandle.transient to register a one-shot handler capability.", DeprecationWarning, 2)
        if not callable(args[0]) or isinstance(args[0], _js):
            self.args = args
            return None
        self.callme = args[0]
        self(*args[1:], **kw)


    def __call__(self, *args, **kw):
        if self.callme is None:
            self.callme = args[0]
            args = args[1:]

        self.args += args
        self.outsideAttribute = kw.get('outsideAttribute')
        bubble = kw.get('bubble')
        if bubble:
            self.postlude = ';'
        else:
            self.postlude = handledEventPostlude
        if 'identifier' in kw:
            self.identifier = kw['identifier']

        return self

    content = property((lambda self: flt(self)))


def flattenHandler(handler, ctx):
    client = IClientHandle(ctx)
    iden = handler.identifier
    if iden is None:
        iden = client.nextId()

    iden = '--handler-%s' % (iden,)
    setattr(IHandlerFactory(ctx), 'handle_%s' % (iden,), handler.callme)
    isAttrib = not (handler.outsideAttribute)
    new = JavascriptContext(ctx, tags.invisible[handler.args], isAttrib = isAttrib)
    rv = flat.flatten(js.nevow_clientToServerEvent(*(iden, this, '') + handler.args), new)
    rv += handler.postlude
    return tags.xml(rv)

flat.registerFlattener(flattenHandler, handler)

def flt(stan, quote = True, client = None, handlerFactory = None):
    '''Flatten some stan to a string suitable for embedding in a javascript
    string.

    If quote is True, apostrophe, quote, and newline will be quoted
    '''
    warnings.warn("[0.5] livepage.flt is deprecated. Don't use it.", DeprecationWarning, 2)
    testutil = testutil
    import nevow
    fr = testutil.FakeRequest()
    ctx = context.RequestContext(tag = fr)
    ctx.remember(client, IClientHandle)
    ctx.remember(handlerFactory, IHandlerFactory)
    ctx.remember(None, inevow.IData)
    fl = flat.flatten(stan, ctx = ctx)
    if quote:
        fl = fl.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n')

    return fl